package org.krivtsun.scanlab.editor;

import javax.swing.*;
import java.awt.*;
import java.awt.image.BufferedImage;
import java.awt.image.RenderedImage;

/**
 * todo Implement dyn. ticks
 *
 * @author Andrew Krivtsun
 */
class Rule extends JComponent {
    public static final int HORIZONTAL = 0;
    public static final int VERTICAL = 1;

    private static final int SIZE = 35;
    private static final Color BACKGROUND_COLOR = new Color(230, 163, 4);
    private static final Font TEXT_FONT = new Font("SansSerif", Font.PLAIN, 10);

    private int orientation;
    private int increment;
    private int units;

    private RenderedImage img;
    private double scale = 1;

    public Rule(int o) {
        orientation = o;
        units = 10;
        increment = 5;
    }

    void setImage(RenderedImage img) {
        this.img = img;
        updatePreferredSize();
    }

    void setScale(double scale) {
        this.scale = scale;
        increment *= scale;
        updatePreferredSize();
    }

    private void updatePreferredSize() {
        long width = img == null? 0: Math.round(img.getWidth()*scale);
        long height = img == null? 0: Math.round(img.getHeight()*scale);
        setPreferredSize(new Dimension((int)width, (int)height));
        revalidate();
        repaint();
    }

    public void setPreferredSize(Dimension dim) {
        if (orientation == HORIZONTAL) {
            super.setPreferredSize(new Dimension(dim.width, SIZE));
        } else {
            super.setPreferredSize(new Dimension(SIZE, dim.height));
        }
    }

    protected void paintComponent(Graphics g) {
        //Rectangle drawHere = g.getClipBounds();
        Rectangle drawHere = new Rectangle(getPreferredSize());

        // Fill clipping area with dirty brown/orange.
        g.setColor(BACKGROUND_COLOR);
        g.fillRect(drawHere.x, drawHere.y, drawHere.width, drawHere.height);

        // Do the ruler labels in a small font that's black.
        g.setFont(TEXT_FONT);
        g.setColor(Color.black);

        // Some vars we need.
        int end = 0;
        int start = 0;
        int tickLength = 0;
        String text = null;

        // Use clipping bounds to calculate first and last tick locations.
        if (orientation == HORIZONTAL) {
            start = (drawHere.x / increment) * increment;
            end = (((drawHere.x + drawHere.width) / increment) + 1)
                  * increment;
        } else {
            start = (drawHere.y / increment) * increment;
            end = (((drawHere.y + drawHere.height) / increment) + 1)
                  * increment;
        }
//        System.out.println("start ="+start);
//        System.out.println("end ="+end);
        // Make a special case of 0 to display the number
        // within the rule and draw a units label.
        if (start == 0) {
            text = Integer.toString(0) + " pcx";
            tickLength = 10;
            if (orientation == HORIZONTAL) {
                g.drawLine(0, SIZE-1, 0, SIZE-tickLength-1);
                g.drawString(text, 2, 21);
            } else {
                g.drawLine(SIZE-1, 0, SIZE-tickLength-1, 0);
                g.drawString(text, 9, 10);
            }
            text = null;
            start = increment;
        }

        // ticks and labels
        for (int i = start; i < end; i += increment) {
            if (i % units == 0)  {
                tickLength = 10;
                text = Integer.toString(i/units);
            } else {
                tickLength = 7;
                text = null;
            }

            if (tickLength != 0) {
                if (orientation == HORIZONTAL) {
                    g.drawLine(i, SIZE-1, i, SIZE-tickLength-1);
                    if (text != null)
                        g.drawString(text, i-3, 21);
                } else {
                    g.drawLine(SIZE-1, i, SIZE-tickLength-1, i);
                    if (text != null)
                        g.drawString(text, 9, i+3);
                }
            }
        }
    }
}
